/* UNIVERSIDAD DEL VALLE DE GUATEMALA  
 * ALGORITMOS Y ESTRUCTURAS DE DATOS
 * PROYECTO 3
 * FELIPE ZELADA
 * JOSUE BARRIENTOS
 */
package timminganalisisp3;
import java.util.ArrayList;
import java.util.Scanner;
import javax.swing.tree.DefaultMutableTreeNode;
/**
 *
 * @author USER
 */
public class Ta {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    int min =1000;
    int max = 0;
    boolean timming = true ;
    String vmax = "con vector:";
    String vmin = "con vector:";
    String ruta1="La ruta es: ";
    String ruta2="La ruta es: ";

        Scanner ingreso = new Scanner(System.in);


        System.out.print("Ingrese el numero de terminales que desea tener: ");
        int numero_de_terminales  = ingreso.nextInt();
        System.out.println("El circuito tendra " + numero_de_terminales + " terminales. ");

        System.out.print("Ingrese el numero de compuertas que desea tener: ");
        int numero_de_compuertas  = ingreso.nextInt();
        System.out.println("El circuito tendra " + numero_de_compuertas + " compuertas. ");

        int numero_de_elementos = 2 + numero_de_compuertas + numero_de_terminales;
        
        int numcompuertas = numero_de_terminales + numero_de_compuertas;
        

        Compuerta[] c = new Compuerta[numero_de_elementos];  // Se crea un array que contiene objetos de la clase Compuerta
        DefaultMutableTreeNode[] nodo = new DefaultMutableTreeNode[10000]; // se crea un array que contiene los nodos del arbol

        c[0] = new Compuerta(0,0,0,6,3,2,2,0,0,0,0); // La compuerta 0 es la que va antes de las terminales y funciona como raiz del arbol
        nodo[0] = new DefaultMutableTreeNode(0); // Se crea el nodo raiz el cual contiene el numero de la compuerta 0


        // Se crean las los objetos compuertas que son las terminales
        for(int i = 1; i <= numero_de_terminales; i++ )
        {

                c[i] = new Compuerta(i,0,0,6,3,2,2,0,0,0,0);
                nodo[i] = new DefaultMutableTreeNode(i);
                nodo[0].add(nodo[i]);
        }

        int nodos_creados = numero_de_terminales;

        // Se crean los objetos de la clase Compuerta que son las compuertas del circuitos

        for(int s = numero_de_terminales + 1; s <= numero_de_compuertas + numero_de_terminales; s++)
        {

            //Crea la con el mismo numero que el contador del for
            c[s] = new Compuerta(s,0,0,0,3,3,3,0,0,0,0);

            // Pide el tipo de compuerta, de la compuerta numero s
            System.out.println("Ingrese el tipo de la compuerta "+ s  +": 1 para AND , 2 para NANAD, 3 para OR y 4 para XOR.");
            int vartipo = ingreso.nextInt();
            c[s].settipo(vartipo); //Setea en la compuerta s su tipo

            // Pide el numero de compuerta referido a la terminal 1
            System.out.print("Ingrese el elemento conectado a la terminal 1: ");
            int enlace1 = ingreso.nextInt();
            c[s].setentrada1(enlace1);

              // Pide el tiempo de compuerta, de la compuerta numero s
            System.out.print("Ingrese el tiempo rising de la compuerta "+ s  +" en entrada1: ");
            int vartr1 = ingreso.nextInt();
            c[s].settrising1(vartr1); //Setea rising en entrada 1

            System.out.print("Ingrese el tiempo falling de la compuerta "+ s  +" en entrada1: ");
            int vartf1 = ingreso.nextInt();
            c[s].settfalling1(vartf1); //Setea falling en entrada 1



            // Crea nodos hijo a todos lo nodos que contengan el numero de
            // compuerta referido a la terminal 1

            for(int p = 0;p <= nodos_creados; p++)
            {

                String cvalor1 ="" + nodo[p].getUserObject();
                int valor1 = Integer.parseInt(cvalor1);

                if(valor1 == enlace1)
                {
                nodo[nodos_creados + 1] = new DefaultMutableTreeNode(s);
                nodo[p].add(nodo[nodos_creados + 1]);
                nodos_creados++;
                }

            }


            // Se crean nodos hijos
            if(vartipo == 5)
            {

                c[s].setentrada2(0);
                c[s].settrising2(0);
                c[s].settfalling2(0);

            }
            else
            {

                System.out.print("Ingrese el elemento conectado a la terminal 2: ");
                int enlace2 = ingreso.nextInt();
                c[s].setentrada2(enlace2);

                 System.out.print("Ingrese el tiempo rising de la compuerta "+ s  +" en entrada2: ");
                int vartr2 = ingreso.nextInt();
                c[s].settrising2(vartr2); //Setea rising en entrada 2

                System.out.print("Ingrese el tiempo falling de la compuerta "+ s  +" en entrada2: ");
                int vartf2 = ingreso.nextInt();
                c[s].settfalling2(vartf2); //Setea falling en entrada 2

                for(int r = 0;r <= nodos_creados; r++)
                {

                    String cvalor2 ="" + nodo[r].getUserObject();
                    int valor2 = Integer.parseInt(cvalor2);

                    if(valor2 == enlace2)
                    {
                    nodo[nodos_creados + 1] = new DefaultMutableTreeNode(s);
                    nodo[r].add(nodo[nodos_creados + 1]);
                    nodos_creados++;
                    }

                }

            }



        }


        for(int t = 0;t <= nodos_creados; t++)
        {
            boolean eshoja = nodo[t].isLeaf();

            // Sensibilizacion
            if(eshoja == true)
            {
              int tamanoruta = nodo[t].getPath().length;

              int m = tamanoruta - 1;
              int n = tamanoruta - 1;
              int v = numcompuertas;

              while(v != 0)
              {
                c[v].setestado(3);
                c[v].setestadoentrada1(3);
                c[v].setestadoentrada2(3);
                c[v].setestadofporuta(false);
                c[v].setcompuertaderuta(false);
                c[v].setnumerodeamb(0);
                v = v - 1;
              }

              while(m != 0)
              {

                  c[Integer.parseInt(nodo[t].getPath()[m].toString())].setcompuertaderuta(true);
                  
                  
                  m = m-1;
              }
              
              String rutita="La ruta es: S";
              while(n != 0)
              {
                  rutita+="-"+c[Integer.parseInt(nodo[t].getPath()[n].toString())].getnumcompuerta();

                  n = n-1;
              }



              while(tamanoruta!= 2)
              {

                
                
                int valorcomp = Integer.parseInt(nodo[t].getPath()[tamanoruta-1].toString());
                int valorcompanterior =  Integer.parseInt(nodo[t].getPath()[tamanoruta-2].toString());
                c[valorcomp].setestado(2);
                c[valorcomp].setestadofporuta(true);
                // Semcibilizacion compuertas tipo AND y NAND

               // 


                if(c[valorcomp].gettipo()== 1 ||c[valorcomp].gettipo()== 2 )
                {
                    if(c[valorcomp].getentrada1()==c[valorcompanterior].getnumcompuerta())
                    {

                        c[valorcomp].setestadoentrada1(2);
                        
                        c[valorcomp].setestadoentrada2(1);
                        
                        int companterior1 = c[valorcomp].getentrada2();
                        c[companterior1].setestado(1);
                        c[companterior1].setestadofporuta(true);
                    }
                    else
                    {
                        c[valorcomp].setestadoentrada1(1);
                        c[valorcomp].setestadoentrada2(2);
                        int companterior2 = c[valorcomp].getentrada1();
                        c[companterior2].setestado(1);
                        c[companterior2].setestadofporuta(true);
                        
                    }
                }

                // Semcibilizacion compuertas tipo OR Y NOR
                if(c[valorcomp].gettipo()== 3||c[valorcomp].gettipo()== 4)
                {
                    if(c[valorcomp].getentrada1()==c[valorcompanterior].getnumcompuerta())
                    {

                        c[valorcomp].setestadoentrada1(2);
                        c[valorcomp].setestadoentrada2(0);
                        int companterior1 = c[valorcomp].getentrada2();
                        c[companterior1].setestado(0);
                        c[companterior1].setestadofporuta(true);

                    }
                    else
                    {
                        c[valorcomp].setestadoentrada1(0);
                        c[valorcomp].setestadoentrada2(2);
                        int companterior2 = c[valorcomp].getentrada1();
                        c[companterior2].setestado(0);
                        c[companterior2].setestadofporuta(true);
                    }

                }
 


                tamanoruta = tamanoruta-1;
              }
              // Setea el valor de salida
              c[Integer.parseInt(nodo[t].getPath()[1].toString())].setestado(2);
              //System.out.println(Integer.parseInt(nodo[t].getPath()[1].toString()));
              //System.out.println(c[1].getestado());
               // Justificacion
              
                ArrayList liscompconamb = new ArrayList();

                int p = numcompuertas;
                int q = 0;
                
                boolean contradicion = false;
                boolean todoestabien = false;

                while(p != 0)
                {
                        if(c[p].getcompuertaderuta() == false || c[p].gettipo() == 6)
                        {
                                int tipocomp;

                                tipocomp = c[p].gettipo();

                                  
                                if(tipocomp == 1 && c[p].getestado() == 1 )
                                {
                                        
                                        c[p].setestadoentrada1(1);
                                        c[p].setestadoentrada2(1);

                                        if(c[c[p].getentrada1()].getestado() == 1 || c[c[p].getentrada1()].getestado() ==3 )
                                        {
                                                c[c[p].getentrada1()].setestado(1);
                                        }
                                        else
                                        {
                                                contradicion = true;
                                                if(liscompconamb.isEmpty()!= true)
                                                {
                                                        q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                }
                                        }

                                        if(c[c[p].getentrada2()].getestado() == 1 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 2
                                        {
                                                c[c[p].getentrada2()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                        }
                                        else
                                        {
                                                contradicion = true;
                                                if(liscompconamb.isEmpty()!= true)
                                                {
                                                        q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                }
                                        }

                                }

                           
                                if(tipocomp == 1 && c[p].getestado() == 0 )
                                {
                                        if(c[p].getnumerodeamb() == 0)
                                        {
                                                liscompconamb.add(p);
                                        }

                                        if(c[p].getnumerodeamb() == 0 && contradicion != true)
                                        {
                                                c[p].setnumerodeamb(1);
                                                c[p].setestadoentrada1(0); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(0); //Setea el estado de las entradas

                                                if(c[c[p].getentrada1()].getestado() == 0 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(0); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;

                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado() == 0 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(0); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }

                                        if(c[p].getnumerodeamb() == 1 && contradicion != true && todoestabien != true)
                                        {
                                                c[p].setnumerodeamb(2);
                                                c[p].setestadoentrada1(0); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(1); //Setea el estado de las entradas

                                                if(c[c[p].getentrada1()].getestado() == 0 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(0); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado() == 1 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }

                                        if(c[p].getnumerodeamb() == 2 && contradicion != true && todoestabien != true)
                                        {
                                                c[p].setnumerodeamb(0);

                                                c[p].setestadoentrada1(1); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(0); //Setea el estado de las entradas

                                                liscompconamb.remove(liscompconamb.size()-1); 


                                                if(c[c[p].getentrada1()].getestado() == 1 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado()== 0 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(0); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }
                                }
 
                                if(tipocomp == 2 && c[p].getestado() == 0)
                                {
                                        c[p].setestadoentrada1(1);
                                        c[p].setestadoentrada2(1);

                                        if(c[c[p].getentrada1()].getestado() == 1 || c[c[p].getentrada1()].getestado() ==3 )
                                        {
                                                c[c[p].getentrada1()].setestado(1);
                                        }
                                        else
                                        {
                                                contradicion = true;
                                                if(liscompconamb.isEmpty()!= true)
                                                {
                                                        q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                }
                                        }

                                        if(c[c[p].getentrada2()].getestado() == 1 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 2
                                        {
                                                c[c[p].getentrada2()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                        }
                                        else
                                        {
                                                contradicion = true;
                                                if(liscompconamb.isEmpty()!= true)
                                                {
                                                        q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                }
                                        }

                                }

                               
                                if(tipocomp == 2 && c[p].getestado() == 1)
                                {
                                        if(c[p].getnumerodeamb() == 0)
                                        {
                                                liscompconamb.add(p);
                                        }

                                        if(c[p].getnumerodeamb() == 0 && contradicion != true)
                                        {
                                                c[p].setnumerodeamb(1);
                                                c[p].setestadoentrada1(0); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(0); //Setea el estado de las entradas

                                                if(c[c[p].getentrada1()].getestado() == 0 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(0); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado() == 0 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(0); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }

                                        if(c[p].getnumerodeamb() == 1 && contradicion != true && todoestabien != true)
                                        {
                                                c[p].setnumerodeamb(2);
                                                c[p].setestadoentrada1(0); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(1); //Setea el estado de las entradas

                                                if(c[c[p].getentrada1()].getestado() == 0 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(0); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado() == 1 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }

                                        if(c[p].getnumerodeamb() == 2 && contradicion != true && todoestabien != true)
                                        {
                                                c[p].setnumerodeamb(0);

                                                c[p].setestadoentrada1(1); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(0); //Setea el estado de las entradas

                                                liscompconamb.remove(liscompconamb.size()-1); 


                                                if(c[c[p].getentrada1()].getestado() == 1 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado() == 0 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(0); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }
                                }

                                
                                if(tipocomp == 3 && c[p].getestado() == 0)
                                {
                                        c[p].setestadoentrada1(0);
                                        c[p].setestadoentrada2(0);

                                        if(c[c[p].getentrada1()].getestado() == 0 || c[c[p].getentrada1()].getestado() ==3 )
                                        {
                                                c[c[p].getentrada1()].setestado(0);
                                        }
                                        else
                                        {
                                                contradicion = true;
                                                if(liscompconamb.isEmpty()!= true)
                                                {
                                                        q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                }
                                        }


                                        if(c[c[p].getentrada2()].getestado() == 0 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 2
                                        {
                                                c[c[p].getentrada2()].setestado(0); // Como el estado de la compuerta enterior era 0 o 3 puede setear un 0 sin que haya contradiccion
                                        }
                                        else
                                        {
                                                contradicion = true;
                                                if(liscompconamb.isEmpty()!= true)
                                                {
                                                        q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                }
                                        }

                                }

                                
                                if(tipocomp == 3 && c[p].getestado() == 1)
                                {
                                        if(c[p].getnumerodeamb() == 0)
                                        {
                                                liscompconamb.add(p);
                                        }

                                        if(c[p].getnumerodeamb() == 0 && contradicion != true)
                                        {
                                                c[p].setnumerodeamb(1);
                                                c[p].setestadoentrada1(1); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(1); //Setea el estado de las entradas

                                                if(c[c[p].getentrada1()].getestado() == 1 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado() == 1 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }

                                        if(c[p].getnumerodeamb() == 1 && contradicion != true && todoestabien != true)
                                        {
                                                c[p].setnumerodeamb(2);
                                                c[p].setestadoentrada1(0); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(1); //Setea el estado de las entradas

                                                if(c[c[p].getentrada1()].getestado() == 0 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(0); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado() == 1 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }

                                        if(c[p].getnumerodeamb() == 2 && contradicion != true && todoestabien != true)
                                        {
                                                c[p].setnumerodeamb(0);

                                                c[p].setestadoentrada1(1); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(0); //Setea el estado de las entradas

                                                liscompconamb.remove(liscompconamb.size()-1); 


                                                if(c[c[p].getentrada1()].getestado() == 1 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado() == 0 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(0); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }
                                }

                               
                                if(tipocomp == 4 && c[p].getestado() == 1)
                                {
                                     
                                        c[p].setestadoentrada1(0);
                                        c[p].setestadoentrada2(0);

                                        if(c[c[p].getentrada1()].getestado() == 0 || c[c[p].getentrada1()].getestado() ==3 )
                                        {
                                                c[c[p].getentrada1()].setestado(0);
                                        }
                                        else
                                        {
                                                contradicion = true;
                                                if(liscompconamb.isEmpty()!= true)
                                                {
                                                        q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                }
                                        }

                                        if(c[c[p].getentrada2()].getestado() == 0 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 2
                                        {
                                                c[c[p].getentrada2()].setestado(0); // Como el estado de la compuerta enterior era 0 o 3 puede setear un 0 sin que haya contradiccion
                                        }
                                        else
                                        {
                                                contradicion = true;
                                                if(liscompconamb.isEmpty()!= true)
                                                {
                                                        q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                }
                                        }

                                }

                            
                                if(tipocomp == 4 && c[p].getestado() == 0)
                                {
                                        if(c[p].getnumerodeamb() == 0)
                                        {
                                                liscompconamb.add(p);
                                        }

                                        if(c[p].getnumerodeamb() == 0 && contradicion != true)
                                        {
                                                c[p].setnumerodeamb(1);
                                                c[p].setestadoentrada1(1); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(1); //Setea el estado de las entradas

                                                if(c[c[p].getentrada1()].getestado() == 1 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado() == 1 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }

                                        if(c[p].getnumerodeamb() == 1 && contradicion != true && todoestabien != true)
                                        {
                                                c[p].setnumerodeamb(2);
                                                c[p].setestadoentrada1(0); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(1); //Setea el estado de las entradas

                                                if(c[c[p].getentrada1()].getestado() == 0 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(0); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado() == 1 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(1); // Como el estado de la compuerta enterior era 1 o 3 puede setear un 1 sin que haya contradiccion
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }

                                        if(c[p].getnumerodeamb() == 2 && contradicion != true && todoestabien != true)
                                        {
                                                c[p].setnumerodeamb(0);

                                                c[p].setestadoentrada1(1); //Setea el estado de las entradas
                                                c[p].setestadoentrada2(0); //Setea el estado de las entradas

                                                liscompconamb.remove(liscompconamb.size()-1); 


                                                if(c[c[p].getentrada1()].getestado() == 1 || c[c[p].getentrada1()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada1()].setestado(1); 
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }

                                                if(c[c[p].getentrada2()].getestado() == 0 || c[c[p].getentrada2()].getestado() ==3 ) //Revisa el estado de la compuerta anterior a la entrada 1
                                                {
                                                        c[c[p].getentrada2()].setestado(0); 
                                                        todoestabien = true;
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }

                                }

                         
                                if(tipocomp == 5)
                                {
                                        if(c[p].getestado() == 1)
                                        {
                                                c[p].setestadoentrada1(0);

                                                if(c[c[p].getentrada1()].getestado() == 0 || c[c[p].getentrada1()].getestado() ==3 )
                                                {
                                                        c[c[p].getentrada1()].setestado(0);
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }
                                        if(c[p].getestado() == 0)
                                        {
                                                c[p].setestadoentrada1(1);
                                                if(c[c[p].getentrada1()].getestado() == 1 || c[c[p].getentrada1()].getestado() ==3 )
                                                {
                                                        c[c[p].getentrada1()].setestado(1);
                                                }
                                                else
                                                {
                                                        contradicion = true;
                                                        if(liscompconamb.isEmpty()!= true)
                                                        {
                                                                q = Integer.parseInt(liscompconamb.get(liscompconamb.size()-1).toString());
                                                        }
                                                }
                                        }


                                }

                                if(contradicion == false)
                                {

                                        todoestabien = false;
                                        if(p == 1)
                                        {
                                                //Se obtiene el vector
                                                    String vector = "El vector es:";
                                                   for (int z=1;z<= numero_de_terminales;z++)
                                                    {
                                                    vector = vector + c[z].getestado()+",";


                                                }
                                                // Timing

                                                    int rising =0;
                                                  int falling= 0;
                                                  int comp = 1;
                                                  int vart = nodo[t].getPath().length;
                                                  int j = vart;
                                                

                                                  while ( j != 0 )
                                                {
                                                  int vari = Integer.parseInt(nodo[t].getPath()[j-1].toString());

                                                  if(c[vari].gettipo()==1 && c[vari].getestadoentrada1()== 2 && comp == 1)
                                                     {
                                                     rising = rising + c[vari].gettiempor1();
                                                     falling = falling + c[vari].gettiempof1();
                                                     }

                                                  else if(c[vari].gettipo()==1 && c[vari].getestadoentrada1()== 2 && comp == 0)
                                                     {
                                                     rising = rising + c[vari].gettiempof1();
                                                     falling = falling + c[vari].gettiempor1();
                                                     }

                                                  else if(c[vari].gettipo()==2 && c[vari].getestadoentrada1()== 2 && comp == 1)
                                                     {
                                                     rising = rising + c[vari].gettiempof1();
                                                     falling = falling + c[vari].gettiempor1();
                                                     comp = 0;
                                                     }

                                                  else if(c[vari].gettipo()==2 && c[vari].getestadoentrada1()== 2 && comp == 0)
                                                     {
                                                     rising = rising + c[vari].gettiempor1();
                                                     falling = falling + c[vari].gettiempof1();
                                                     comp = 1;
                                                     }

                                                     else if(c[vari].gettipo()==4 && c[vari].getestadoentrada1()== 2 && comp == 1)
                                                     {
                                                     rising = rising + c[vari].gettiempof1();
                                                     falling = falling + c[vari].gettiempor1();
                                                     comp = 0;
                                                     }

                                                  else if(c[vari].gettipo()==5 && c[vari].getestadoentrada1()== 2 && comp == 0)
                                                     {
                                                     rising = rising + c[vari].gettiempor1();
                                                     falling = falling + c[vari].gettiempof1();
                                                     comp = 1;
                                                     }

                                                    else if(c[vari].gettipo()==5 && c[vari].getestadoentrada1()== 2 && comp == 1)
                                                     {
                                                     rising = rising + c[vari].gettiempof1();
                                                     falling = falling + c[vari].gettiempor1();
                                                     comp = 0;
                                                     }

                                                  else if(c[vari].gettipo()==4 && c[vari].getestadoentrada1()== 2 && comp == 0)
                                                     {
                                                     rising = rising + c[vari].gettiempor1();
                                                     falling = falling + c[vari].gettiempof1();
                                                     comp = 1;
                                                     }

                                                  else if(c[vari].gettipo()==3 && c[vari].getestadoentrada1()== 2 && comp == 1)
                                                     {
                                                     rising = rising + c[vari].gettiempor1();
                                                     falling = falling + c[vari].gettiempof1();
                                                     }

                                                  else if(c[vari].gettipo()==3 && c[vari].getestadoentrada1()== 2 && comp == 0)
                                                     {
                                                     rising = rising + c[vari].gettiempof1();
                                                     falling = falling + c[vari].gettiempor1();
                                                     }

                                                  else if(c[vari].gettipo()==1 && c[vari].getestadoentrada2()== 2 && comp == 1)
                                                     {
                                                     rising = rising + c[vari].gettiempor2();
                                                     falling = falling + c[vari].gettiempof2();
                                                     }

                                                  else if(c[vari].gettipo()==1 && c[vari].getestadoentrada2()== 2 && comp == 0)
                                                     {
                                                     rising = rising + c[vari].gettiempof2();
                                                     falling = falling + c[vari].gettiempor2();
                                                     }

                                                  else if(c[vari].gettipo()==3 && c[vari].getestadoentrada2()== 2 && comp == 1)
                                                     {
                                                     rising = rising + c[vari].gettiempor2();
                                                     falling = falling + c[vari].gettiempof2();
                                                     }

                                                  else if(c[vari].gettipo()==3 && c[vari].getestadoentrada2()== 2 && comp == 0)
                                                     {
                                                     rising = rising + c[vari].gettiempof2();
                                                     falling = falling + c[vari].gettiempor2();
                                                     }
                                                      else if(c[vari].gettipo()==2 && c[vari].getestadoentrada2()== 2 && comp == 1)
                                                     {
                                                     rising = rising + c[vari].gettiempof2();
                                                     falling = falling + c[vari].gettiempor2();
                                                     comp = 0;
                                                     }

                                                  else if(c[vari].gettipo()==2 && c[vari].getestadoentrada2()== 2 && comp == 0)
                                                     {
                                                     rising = rising + c[vari].gettiempor2();
                                                     falling = falling + c[vari].gettiempof2();
                                                     comp = 1;
                                                     }

                                                     else if(c[vari].gettipo()==4 && c[vari].getestadoentrada2()== 2 && comp == 1)
                                                     {
                                                     rising = rising + c[vari].gettiempof2();
                                                     falling = falling + c[vari].gettiempor2();
                                                     comp = 0;
                                                     }

                                                  else if(c[vari].gettipo()==4 && c[vari].getestadoentrada2()== 2 && comp == 0)
                                                     {
                                                     rising = rising + c[vari].gettiempor2();
                                                     falling = falling + c[vari].gettiempof2();
                                                     comp = 1;
                                                     }

                                                  j=j-1;
                                                 }
                                            if (falling < min)
                                            {
                                                min= falling;
                                                vmin= vector;
                                                ruta2=rutita;

                                            }
                                            if (rising<min)
                                            {
                                                min= rising;
                                                vmin= vector;
                                                ruta2=rutita;

                                            }
                                            if (falling>max)
                                            {
                                                max= falling;
                                                vmax= vector;
                                                ruta1=rutita;
                                            }
                                            if (rising > max)
                                            {
                                                max= rising;
                                                vmax= vector;
                                                ruta1=rutita;
                                            }
                                             

                                             
                                        }
                                        p = p-1;
                                }
                                else
                                {
                                        contradicion = false;
                                        todoestabien = false;
                                        if(liscompconamb.isEmpty() == true)
                                        {

                                                p = 0;
                                                System.out.println("Es falsa!!!");
                                        }
                                        else
                                        {
                                                p = q;
                                                c[q].setestadoentrada1(3);
                                                c[q].setestadoentrada2(3);
                                                q = q-1;

                                                while(q != 0)
                                                {
                                                        if(c[q].getestadofporuta()!= true && c[q].getcompuertaderuta() == false)
                                                        {
                                                                c[q].setestado(3);
                                                                c[q].setestadoentrada1(3);
                                                                c[q].setestadoentrada2(3);
                                                        }
                                                        q = q-1;
                                                }
                                        }
                                }
                        }
                  else
                  {
                                p = p-1;
                  }



                }

             
            }

            
        }
 vmax=vmax.replace("2", "C");
 System.out.println("\nResultados:\nEl tiempo maximo es: "+max+"\n"+vmax );
 System. out.println(ruta1);
 vmin=vmin.replace("2", "C");
 System. out.println("\nEl tiempo minimo es: "+min +"\n"+vmin);
 System. out.println(ruta2);
 
    
}
}
